;;;;;
var U = (function(window,document){
    
/*  getStyle(ele,attr)  获取非行间样式
* ele { object }  元素
* attr  {string} 样式名
*/

function getStyle (ele, attr) {
    //做兼容处理
    if (window.getComputedStyle) { // 如果此方法不存在  undefined  假  
        return window.getComputedStyle(ele)[attr]
    } else {
        return ele.currentStyle[attr]
    }
}
/*move(ele,attr,target,step) 运动函数
* ele { object }  元素
* attr  {string} 样式名
* target  {number} 目标值
* step  {number} 步长
* callback {function} 回调函数
*/
function move(ele, attr, target, step,callback) {
    step = parseInt(getStyle(ele, attr))>target?-step:step
    // step 为正值还是为负值
    // 目标值 向右  currentLeft(0) target（500）    target>currentLeft   step  10 
    // 目标值 向左  currentLeft(500) target（0）    target<currentLeft   step -10
    //在频繁触发定时器之前清楚定时器  
    clearInterval(ele.timer)
    ele.timer = setInterval(function () {
        //获取当前的left值
        var currentLetf = parseInt(getStyle(ele, attr))
        currentLetf = currentLetf + step             
        // 向右运动的                         向左运动的
        if ((currentLetf >= target && step > 0) || (currentLetf <= target && step < 0)) {
            currentLetf = target
            //到达500位置 停止定时器
            clearInterval(ele.timer)
            //运动完之后调用函数  
            if(callback){ //判断传了没有
                callback()
            }
            
        }
        // 赋值
        ele.style[attr] = currentLetf + 'px'
    }, 50)
}

/* random(max,min)  随机数
* max { number } 最大值
* min { number } 最小值
*/

function random(max,min){
    return Math.floor(Math.random()*(max-min+1)+min)
}

/* cover(time)  随机数
* time { number|string }  需要补位的数
*/

function cover(time){
    return time>9?time:'0'+time
}

/* norepead(str)  字符串去重
* str { string }  要去重的字符串
*/

function norepead(str){
    //新创建一个空字符串 （去重之后的字符串）
    var newStr = '' 
    for(var i=0;i<str.length;i++){
        if(newStr.indexOf(str[i])==-1){
            newStr+=str[i]
        }
    }
    return newStr
}
/* verCode(n)  n为随机验证码
* n { number }  验证码的位数
*/


function verCode(n){
    //默认值
    n?n:n=4
    var s = ''// 最终的验证码
    var str = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'
    //取出随机的字符拼接到s内 
    for(var i=0;i<n;i++){
        //随机数的范围  0 -  str.length -1
       s+=str[Math.floor(Math.random()*(str.length -1 -0 +1)+0)]
    }
    return s
}


/* sort(arr) //数组排序
* arr { array } 需要排序的数组
*注意：选择排序，冒泡排序必须是纯字符串或者纯数字进行比较  不能混搭
*/
function sort(arr) {
    console.log(arr);
    for (var i = 0; i < arr.length - 1; i++) {
        for (var k = 0; k < arr.length - 1 - i; k++) {
            if (arr[k] > arr[k + 1]) {
                var tem = arr[k + 1]
                arr[k + 1] = arr[k]
                arr[k] = tem
            }
        }
    }
    return arr
}
/* indexOf(str,s,startindex)  类似于字符串的indexOf方法
* str { string } 字符串
* s { string } 寻找的字符
* startindex { number } 开始下标
*注意：选择排序，冒泡排序必须是纯字符串或者纯数字进行比较  不能混搭
*/
function indexOf(str,s,startindex){
    // 1、startindex 传了没有  （函数的默认值）
    startindex?startindex:startindex =0
    // 2、循环判断
    for(var i=startindex;i<str.length;i++){
       if(str[i]==s){
        return i
       }
    }
    return -1
 }
/* insertAfter(newNode,oldNode)  类似于inserBefore方法  在参考节点后添加
* newNode { object }  要插入的节点
* oldNode { object }  参考节点
*/

 function insertAfter(newNode,oldNode){
    //获取参考节点的父级
    var parent = oldNode.parentNode
    // 判断
    var nextLi = oldNode.nextElementSibling ||oldNode.nextSibling
    if(nextLi.nodeType == 1){//有
        parent.insertBefore(newNode,nextLi)
    }else{
        parent.appendChild(newNode)
    }
}

/* Attr(el,attr,value)  设置和获取元素的属性 （两个值是获取 三个是设置）
* el { object }  元素
* attr { string } 属性
* value { any  }  属性值
*/
function Attr(el,attr,value){
    //判断是设置还是获取
    if(value){ //设置
        el.setAttribute(attr,value)
    }else{ //获取
        return el.getAttribute(attr)
    }
}

/* bind(el,type,fnEvent)  事件绑定的兼容
* el { object }  元素
* type { string } 事件类型
* fnEvent { function  }  事件函数
*/

function bind(el,type,fnEvent){
    // 判断是什么浏览器
    if(el.addEventListener){
        // console.log('标准浏览器,iE8以上');
        el.addEventListener(type,fnEvent,false)
    }else{
        // console.log('iE8以下');
        el.attachEvent('on'+type,fnEvent)
    }
}
/* unbind(el,type,fnEvent)  事件绑定的兼容
* el { object }  元素
* type { string } 事件类型
* fnEvent { function  }  事件函数
*/

function unbind(el,type,fnEvent){
    // 判断是什么浏览器
    if(el.removeEventListener){
        el.removeEventListener(type,fnEvent,false)
    }else{
        el.detachEvent('on'+type,fnEvent)
    }
}
/* Drag(el)   拖拽
* el { object }  元素
*/

function Drag(el) {
    el.onmousedown = function (e) {
        //  判断是什么浏览器
        if (el.setCapture) {
            el.setCapture()
        }
        var ev = window.event || e
        // 求鼠标距离盒子左边和上边的距离
        var mouseX = ev.clientX - el.offsetLeft
        var mouseY = ev.clientY - el.offsetTop

        //给el 添加移动事件
        document.onmousemove = function (e) {
            var ev = window.event || e
            //让盒子移动 （求盒子的left 和 top）
            var moveBoxL = ev.clientX - mouseX
            var moveBoxT = ev.clientY - mouseY

            el.style.left = moveBoxL + 'px'
            el.style.top = moveBoxT + 'px'
        }
        //鼠标抬起  清楚移动事件
        document.onmouseup = function () {
            document.onmousemove = null


            //抬起释放全局捕获
            if (el.releaseCapture) {
                el.releaseCapture()
            }


        }
        return false //阻止标准默认事件
        // ev.preventDefault()
        // ev.returnValue = false
        console.log(ev);
    }
}

/*Move(ele,attr,target,step) 运动函数
* ele { object }  元素
* attr  {string} 属性名
* target  {number} 目标值
* callback {function} 回调函数
*/
    // 参数：el 元素  attr 运动的属性 target 目标值
    function Move(el,attr,target,callback){
        //频发触发定时器之前 清楚定时器
        clearInterval(el.timer)
        el.timer = setInterval(function(){
        var  current =  parseInt(getStyle(el,attr))
        //在遇到到达不了0的情况下需要向下取整
        var speed =  target >current?Math.ceil((target-current)/10): Math.floor((target-current)/10)
        if(current==target){
            clearInterval(el.timer)
            //运动完成，调用回调函数
            // callback && callback() 方式一
            if(callback){ // 方式一
                callback()
            }
        }
        el.style[attr] = current + speed  + 'px'
       },30)  
    }
/*opacity(ele,attr,target,step) 运动函数
* ele { object }  元素
* attr  {string} 属性名
* target  {number} 目标值
* callback {function} 回调函数
*/

//参数  元素el  运动的属性attr 目标值target 
function opacity(el,attr,target,callback){
    //频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function () {
        //1、获取当前的opacity
        var current = parseFloat(getStyle(el, attr)) * 100
        var end = target * 100 //目标值扩大100倍
        var speed = current>end? Math.floor((end - current) / 10): Math.ceil((end - current) / 10)
        if (current == end) {
            clearInterval(el.timer)
            //到大目标值 调用回调函数
            callback && callback()
        }
        el.style[attr] = (current + speed) / 100
    }, 30)
}


/*opacityAttr(ele,attr,target,step) 运动函数
* ele { object }  元素
* attr  {string} 属性名
* target  {number} 目标值
* callback {function} 回调函数
*/

//参数  元素el  运动的属性attr 目标值target 
function opacityAttr(el,attr,target,callback){
    //频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function () {
        if(attr==='opacity'){
            //1、获取当前的opacity
            var current = parseFloat(getStyle(el, attr)) * 100
            var end = target * 100 //目标值扩大100倍
            var speed = current>end? Math.floor((end - current) / 10): Math.ceil((end - current) / 10)
            if (current == end) {
                clearInterval(el.timer)
                //到大目标值 调用回调函数
                callback && callback()
            }
        el.style[attr] = (current + speed) / 100
        }else{
            var  current =  parseInt(getStyle(el,attr))
            var speed =  target >current?Math.ceil((target-current)/10): Math.floor((target-current)/10)
            if(current==target){
            clearInterval(el.timer)
            //运动完成，调用回调函数
            // callback && callback() 方式一
                if(callback){ // 方式一
                    callback()
                }
            }
            el.style[attr] = current + speed  + 'px'
        }
    }, 30)
}

/*BufferMove(ele,attr,target,step) 运动函数
* ele { object }  元素
* attr  {string} 属性名
* target  {number} 目标值
* callback {function} 回调函数
*/

  //参数  元素el  运动的属性attr 目标值target 
  function BufferMove(el, obj, callback) {
    //频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function () {
        var flag = '都到了' //都到了
        //循环对象取出对应的key 及key对应的值
        for (var key in obj) {
            // key :运动的属性
            // obj[key]: 属性对应的鼠标指
            if (key === 'opacity') {
                //1、获取当前的opacity
                var current = parseFloat(getStyle(el, key)) * 100
                var end = obj[key] * 100 //目标值扩大100倍
                var speed = current > end ? Math.floor((end - current) / 10) : Math.ceil((end - current) / 10)
                if (current != end) {
                    //没到
                    flag = '没到'
                }
                el.style[key] = (current + speed) / 100
            } else {
                var current = parseInt(getStyle(el, key))
                var speed = obj[key] > current ? Math.ceil((obj[key] - current) / 10) : Math.floor((obj[key] - current) / 10)
                if (current != obj[key]) {
                    flag = '没到'
                }
                el.style[key] = current + speed + 'px'
            }
        }
        //听过for- in循环之后既可以确定到还是没到
        if(flag == '都到了'){
            clearInterval(el.timer)
            //运动完成，调用回调函数
            callback && callback()
        }
    }, 30)
}
/*Storage(key, value) 本地存和取
* key { string }  对象的key
* value  { any } 不能是undefiend
*/
function Storage(key, value) {
    //判断是取还是存
    if (value) {
        //存
        // 判断是什么类型
        console.log();
        if (typeof (value) == "object") {
            localStorage[key] = JSON.stringify(value)
        } else {
            localStorage[key] = value
        }
    } else {
        // console.log(localStorage[key] != undefined);
        //取
        if (localStorage[key] != undefined) {
            return JSON.parse(localStorage[key])
        }else{
            return ""
        }
    }
}


return {
    BufferMove,
    opacityAttr,
    opacity,
    Move,
    Drag,
    unbind,
    bind,
    Attr,
    insertAfter,
    indexOf,
    sort,
    verCode,
    norepead,
    cover,
    random,
    move,
    getStyle,
    Storage

}

})(window,document)